package com.example.myapplication.utils

import android.content.Context
import android.content.SharedPreferences
import android.util.Log
import kotlinx.coroutines.*
import java.net.HttpURLConnection
import java.net.URL

/**
 * 增强版服务器配置管理 - 支持多网络环境数据互通
 */
object ServerConfig {
    private const val PREFS_NAME = "server_config"
    private const val KEY_SERVER_URL = "server_url"
    private const val KEY_USE_PUBLIC_SERVER = "use_public_server"
    private const val KEY_BACKUP_SERVERS = "backup_servers"
    private const val KEY_AUTO_SWITCH = "auto_switch"
    
    private const val TAG = "ServerConfig"
    
    // 预配置的服务器列表（按优先级排序）
    private val DEFAULT_SERVERS = listOf(
        "ws://8.140.59.178:8085",  // 您的云服务器（跨网络数据传输服务器）
        "ws://8.140.59.178:8080",  // 备用云服务器
        "ws://echo.websocket.org",  // WebSocket测试服务器
        "ws://192.168.1.100:8085", // 常见内网地址
        "ws://10.0.0.100:8085"     // 另一个内网地址
    )
    
    /**
     * 智能获取最佳服务器URL
     */
    suspend fun getBestServerUrl(context: Context): String {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        val usePublicServer = prefs.getBoolean(KEY_USE_PUBLIC_SERVER, false)
        val autoSwitch = prefs.getBoolean(KEY_AUTO_SWITCH, true)
        
        // 如果指定使用公网服务器
        if (usePublicServer) {
            val publicUrl = prefs.getString(KEY_SERVER_URL, "") ?: ""
            if (publicUrl.isNotEmpty()) {
                // 测试公网服务器连通性
                if (autoSwitch && !testServerConnectivity(publicUrl)) {
                    Log.w(TAG, "公网服务器不可达，尝试其他服务器")
                    return findAvailableServer(context)
                }
                return publicUrl
            }
        }
        
        // 智能选择最佳服务器
        return if (autoSwitch) {
            findAvailableServer(context)
        } else {
            getLocalServerUrl(context)
        }
    }
    
    /**
     * 查找可用的服务器
     */
    private suspend fun findAvailableServer(context: Context): String {
        val servers = mutableListOf<String>()
        
        // 添加本地检测到的服务器
        servers.add(getLocalServerUrl(context))
        
        // 添加默认服务器列表
        servers.addAll(DEFAULT_SERVERS)
        
        // 添加用户自定义的备用服务器
        val backupServers = getBackupServers(context)
        servers.addAll(backupServers)
        
        // 并发测试所有服务器
        return withContext(Dispatchers.IO) {
            val availableServers = servers.map { serverUrl ->
                async {
                    if (testServerConnectivity(serverUrl)) {
                        Pair(serverUrl, true)
                    } else {
                        Pair(serverUrl, false)
                    }
                }
            }.awaitAll().filter { it.second }.map { it.first }
            
            if (availableServers.isNotEmpty()) {
                val bestServer = availableServers.first()
                Log.d(TAG, "找到可用服务器: $bestServer")
                bestServer
            } else {
                Log.w(TAG, "没有找到可用服务器，使用默认地址")
                DEFAULT_SERVERS.first()
            }
        }
    }
    
    /**
     * 测试服务器连通性
     */
    private suspend fun testServerConnectivity(serverUrl: String): Boolean {
        return withContext(Dispatchers.IO) {
            try {
                // 将WebSocket URL转换为HTTP URL进行连通性测试
                val httpUrl = serverUrl
                    .replace("ws://", "http://")
                    .replace("wss://", "https://")
                    .replace("/ws", "") // 移除WebSocket路径
                
                val url = URL(httpUrl)
                val connection = url.openConnection() as HttpURLConnection
                connection.requestMethod = "GET"
                connection.connectTimeout = 3000 // 3秒超时
                connection.readTimeout = 3000
                
                val responseCode = connection.responseCode
                connection.disconnect()
                
                // 200-399之间的响应码都认为是可连通的
                val isConnectable = responseCode in 200..399
                Log.d(TAG, "服务器 $serverUrl 连通性测试: $isConnectable (响应码: $responseCode)")
                isConnectable
            } catch (e: Exception) {
                Log.d(TAG, "服务器 $serverUrl 连通性测试失败: ${e.message}")
                false
            }
        }
    }
    
    /**
     * 获取服务器URL（同步方法，用于兼容现有代码）
     */
    fun getServerUrl(context: Context): String {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        val usePublicServer = prefs.getBoolean(KEY_USE_PUBLIC_SERVER, false)
        
        return if (usePublicServer) {
            prefs.getString(KEY_SERVER_URL, "") ?: getLocalServerUrl(context)
        } else {
            getLocalServerUrl(context)
        }
    }
    
    /**
     * 设置公网服务器URL
     */
    fun setPublicServerUrl(context: Context, url: String) {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        prefs.edit()
            .putString(KEY_SERVER_URL, url)
            .putBoolean(KEY_USE_PUBLIC_SERVER, true)
            .apply()
        Log.d(TAG, "设置公网服务器URL: $url")
    }
    
    /**
     * 添加备用服务器
     */
    fun addBackupServer(context: Context, serverUrl: String) {
        val backupServers = getBackupServers(context).toMutableList()
        if (!backupServers.contains(serverUrl)) {
            backupServers.add(serverUrl)
            saveBackupServers(context, backupServers)
            Log.d(TAG, "添加备用服务器: $serverUrl")
        }
    }
    
    /**
     * 获取备用服务器列表
     */
    private fun getBackupServers(context: Context): List<String> {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        val serversStr = prefs.getString(KEY_BACKUP_SERVERS, "") ?: ""
        return if (serversStr.isEmpty()) {
            emptyList()
        } else {
            serversStr.split(",").filter { it.isNotEmpty() }
        }
    }
    
    /**
     * 保存备用服务器列表
     */
    private fun saveBackupServers(context: Context, servers: List<String>) {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        prefs.edit()
            .putString(KEY_BACKUP_SERVERS, servers.joinToString(","))
            .apply()
    }
    
    /**
     * 设置是否启用自动切换
     */
    fun setAutoSwitchEnabled(context: Context, enabled: Boolean) {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        prefs.edit()
            .putBoolean(KEY_AUTO_SWITCH, enabled)
            .apply()
        Log.d(TAG, "自动切换服务器: $enabled")
    }
    
    /**
     * 切换到本地服务器
     */
    fun switchToLocalServer(context: Context) {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        prefs.edit()
            .putBoolean(KEY_USE_PUBLIC_SERVER, false)
            .apply()
        Log.d(TAG, "切换到本地服务器")
    }
    
    /**
     * 获取本地服务器URL（增强版）
     */
    private fun getLocalServerUrl(context: Context): String {
        // 检查是否为模拟器
        if (isEmulator()) {
            Log.d(TAG, "检测到模拟器，使用本地服务器地址")
            return "ws://172.21.0.238:8085"  // 模拟器使用实际本地IP
        }
        
        // 非模拟器使用跨网络数据传输服务器
        Log.d(TAG, "使用跨网络数据传输服务器")
        return DEFAULT_SERVERS.first()  // 返回第一个默认服务器（ws://8.140.59.178:8085）
    }
    
    /**
     * 检查是否为模拟器
     */
    private fun isEmulator(): Boolean {
        return try {
            val buildModel = android.os.Build.MODEL
            val buildProduct = android.os.Build.PRODUCT
            val buildFingerprint = android.os.Build.FINGERPRINT
            
            buildModel.contains("sdk") || 
            buildModel.contains("google_sdk") || 
            buildModel.contains("Emulator") ||
            buildProduct.contains("sdk") ||
            buildProduct.contains("google_sdk") ||
            buildProduct.contains("Emulator") ||
            buildFingerprint.contains("generic")
        } catch (e: Exception) {
            false
        }
    }
    
    /**
     * 检查是否使用公网服务器
     */
    fun isUsingPublicServer(context: Context): Boolean {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        return prefs.getBoolean(KEY_USE_PUBLIC_SERVER, false)
    }
    
    /**
     * 获取当前服务器配置信息(增强版)
     */
    fun getServerInfo(context: Context): String {
        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        val usePublicServer = prefs.getBoolean(KEY_USE_PUBLIC_SERVER, false)
        val autoSwitch = prefs.getBoolean(KEY_AUTO_SWITCH, true)
        
        return if (usePublicServer) {
            val url = prefs.getString(KEY_SERVER_URL, "") ?: ""
            "公网服务器: $url${if (autoSwitch) " (智能切换)" else ""}"
        } else {
            val localUrl = getLocalServerUrl(context)
            "本地服务器: $localUrl${if (autoSwitch) " (智能切换)" else ""}"
        }
    }
    
    /**
     * 获取所有可用服务器列表
     */
    fun getAllAvailableServers(context: Context): List<String> {
        val servers = mutableListOf<String>()
        servers.add(getLocalServerUrl(context))
        servers.addAll(DEFAULT_SERVERS)
        servers.addAll(getBackupServers(context))
        return servers.distinct()
    }
    
    /**
     * 验证服务器URL格式
     */
    fun isValidServerUrl(url: String): Boolean {
        return url.matches(Regex("^wss?://[\\w.-]+(:[0-9]+)?(/.*)?$"))
    }
} 